package com.example.XqmZsb.controller;

import com.example.XqmZsb.dao.DaoDemo;
import com.example.XqmZsb.domian.Enrollment;
import com.example.XqmZsb.domian.Enrollmentinfo;
import com.example.XqmZsb.domian.Majorinfo;
import com.example.XqmZsb.domian.Schoolmajorinfo;
import com.example.XqmZsb.service.Dome01Service;
import com.example.XqmZsb.utils.ApiResponse;
import com.example.XqmZsb.utils.BaseResponse;
import com.example.XqmZsb.utils.ErrorCode;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
public class UserController {

    @Resource
    private Dome01Service service;

    @Resource
    private DaoDemo daoDemo;


    private List  list;

    /*@RequestMapping("/getusers")
    public List<Dome01> getUsers(){
        return daoDemo.SelectAll();
    }*/

    @RequestMapping("/getusers")
    private Object getUser(){
        return service.findByAll2();
    }

    @RequestMapping("/ban")
    public BaseResponse error(){
        return BaseResponse.error(ErrorCode.VERIFY_NO_PASS);
    }

    /*@PostMapping("/search")
    public List<Dome01> searchByName(@RequestBody Map<String ,Object> Dome01) {
        String key = ""; // 获取字段名称
        Object value = null;// 获取对应的值
        Integer size = Dome01.size();
        if (size >= 1) {
            for (Map.Entry<String, Object> entry : Dome01.entrySet()) {
                key = entry.getKey(); // 获取字段名称
                value = entry.getValue(); // 获取对应的值
            }
        }
        return service.findByKey2(key,value);
    }*/
    /**
     * 通过类似学科编号进行搜索的方法。《查询该编号对应的所有信息》
     */
    @PostMapping("/juniorMajorCode")
    public List<Enrollment> searchByName(@RequestBody Map<String, Object> queryConditions) {
        // 创建一个存储查询条件的对象或Map
        Map<String, Object> conditionMap = new HashMap<>();

        // 遍历请求体中的所有键值对
        for (Map.Entry<String, Object> entry : queryConditions.entrySet()) {
            // 将每一个键值对添加到条件集合中
            conditionMap.put(entry.getKey(), entry.getValue());
        }
        // 下面的代码仅为示例，您需根据实际情况调整
        return service.findWithMultipleConditions(conditionMap);
    }
    /**
     * 通过类似名称进行搜索的方法。《搜素框模糊查询全部学科接口》 返回状态码
     * @return
     */
    @PostMapping("/juniorErrorCode")
    public ResponseEntity<ApiResponse<List<Enrollment>>> searchByErrorCode(@RequestBody Map<String, Object> queryConditions) {
        try {
            // 创建一个存储查询条件的对象或Map
            Map<String, Object> conditionMap = new HashMap<>();

            // 遍历请求体中的所有键值对
            for (Map.Entry<String, Object> entry : queryConditions.entrySet()) {
                // 将每一个键值对添加到条件集合中
                conditionMap.put(entry.getKey(), entry.getValue());
            }

            // 查询成功，返回状态码 200 和正确数据
            List<Enrollment> enrollments = service.findWithNameLike(conditionMap);
            ApiResponse<List<Enrollment>> successResponse = new ApiResponse<>(HttpStatus.OK.value(), "查询成功", enrollments);

            // 使用Builder模式创建并返回 ResponseEntity
            return ResponseEntity.status(HttpStatus.OK)
                    .body(successResponse);
        } catch (Exception e) {
            // 处理查询过程中出现的异常，返回状态码 500 和错误信息
            String errorMessage = "An error occurred while processing the request: " + e.getMessage();
            ApiResponse<List<Enrollment>> errorResponse = new ApiResponse<>(HttpStatus.INTERNAL_SERVER_ERROR.value(), errorMessage, Collections.emptyList());

            // 使用Builder模式创建并返回 ResponseEntity
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(errorResponse);
        }
    }
    /**
     * 通过类似名称进行搜索的方法。《搜素框模糊查询全部学科接口》
     */
    @PostMapping("/juniorMajor")
    public List<Enrollment> searchByLikeName(@RequestBody Map<String, Object> queryConditions) {
        // 创建一个存储查询条件的对象或Map
        Map<String, Object> conditionMap = new HashMap<>();

        // 遍历请求体中的所有键值对
        for (Map.Entry<String, Object> entry : queryConditions.entrySet()) {
            // 将每一个键值对添加到条件集合中
            conditionMap.put(entry.getKey(), entry.getValue());
        }

        return service.findWithNameLike(conditionMap);
    }
    /**
     * 通过专业代码进行搜索的方法。《搜素有这个专业的学校接口》
     */
    @PostMapping("/majorCodes")
    public List<Enrollmentinfo> searchByNameIn(@RequestBody Map<String, Object> queryConditions) {
        // 创建一个存储查询条件的对象或Map
        Map<String, Object> conditionMap = new HashMap<>();

        // 针对"name"字段进行特殊处理，将其从字符串转换为列表
        if (queryConditions.containsKey("major")) {
            String namesStr = (String) queryConditions.get("major");
            conditionMap.put("names", namesStr.split(","));
        } else {
            // 如果没有提供"name"字段，则无需特殊处理，直接将其他键值对添加到条件集合中
            for (Map.Entry<String, Object> entry : queryConditions.entrySet()) {
                conditionMap.put(entry.getKey(), entry.getValue());
            }
        }

        // 调用Service层的findWithNameIn方法
        return service.findWithNameIn(conditionMap);
    }
    /**
     * 通过专业代码和学校名称进行搜索的方法。《搜素有这个专业的学校接口》
     */
    @PostMapping("/majorSchool")
    public List<Enrollmentinfo> searchBySchool(@RequestBody Map<String, Object> param) {
        // 直接创建一个存储查询条件的对象或Map
        Map<String, Object> codeMap = new HashMap<>();
        Map<String, Object> SchoolMap = new HashMap<>();
        Map<String, Object> natureMap = new HashMap<>();

        // 针对"name"字段进行特殊处理，将其从字符串转换为列表
        if (param.containsKey("major") && param.containsKey("enrollingCollege")&& param.containsKey("schoolNature")) {
            String codeStr = (String) param.get("major");
            codeMap.put("major", codeStr.split(","));
            codeMap.put("majorLength", codeStr.length());
            String schoolStr = (String) param.get("enrollingCollege");
            SchoolMap.put("enrollingCollege", schoolStr.split(","));
            SchoolMap.put("enrollingCollegeLength", schoolStr.length());
            String natureStr = (String) param.get("schoolNature");
            natureMap.put("schoolNature", natureStr.split(","));
            natureMap.put("schoolNatureLength", natureStr.length());
        }

        // 调用Service层的findWithSchool方法
        return service.findWithSchool(codeMap,SchoolMap,natureMap);
    }
    @RequestMapping(value = "/hello",method = RequestMethod.GET)
    private String hello(){
        return "hello";
    }


    /////////////////////////////XqmZsb接口//////////////////////////////////
    /**
     * 接口一： 专科专业名称  模糊查询 专科专业名称和代码
     */
    @PostMapping("/XqmZsbLikeName")
    public List<Majorinfo> XqmZsbLikeName(@RequestBody Map<String, Object> queryConditions) {
        // 创建一个存储查询条件的对象或Map
        Map<String, Object> conditionMap = new HashMap<>();

        // 遍历请求体中的所有键值对
        for (Map.Entry<String, Object> entry : queryConditions.entrySet()) {
            // 将每一个键值对添加到条件集合中
            conditionMap.put(entry.getKey(), entry.getValue());
        }

        return service.XqmZsbLikeName(conditionMap);
    }
    /**
     * 接口二： 专科专业代码  查询对应 专科专业小类代码 和小类名称
     */
    @PostMapping("/XqmZsbSubName")
    public List<Majorinfo> XqmZsbSubName(@RequestBody Map<String, Object> queryConditions) {
        // 创建一个存储查询条件的对象或Map
        Map<String, Object> conditionMap = new HashMap<>();

        // 遍历请求体中的所有键值对
        for (Map.Entry<String, Object> entry : queryConditions.entrySet()) {
            // 将每一个键值对添加到条件集合中
            conditionMap.put(entry.getKey(), entry.getValue());
        }

        return service.XqmZsbSubName(conditionMap);
    }
    /**
     * 接口三： 专科专业小类代码  查询对应 本科专业小类代码 和小类名称
     */
    @PostMapping("/XqmZsbBKSubName")
    public List<Majorinfo> XqmZsbBKSubName(@RequestBody Map<String, Object> queryConditions) {
        // 创建一个存储查询条件的对象或Map
        Map<String, Object> conditionMap = new HashMap<>();

        // 遍历请求体中的所有键值对
        for (Map.Entry<String, Object> entry : queryConditions.entrySet()) {
            // 将每一个键值对添加到条件集合中
            conditionMap.put(entry.getKey(), entry.getValue());
        }

        return service.XqmZsbBKSubName(conditionMap);
    }
    /**
     * 接口四： 按专业：本科小类代码 查询对应 本科专业代码和名称
     */
    @PostMapping("/XqmZsbBKName")
    public List<Majorinfo> XqmZsbBKName(@RequestBody Map<String, Object> queryConditions) {
        // 创建一个存储查询条件的对象或Map
        Map<String, Object> conditionMap = new HashMap<>();

        // 遍历请求体中的所有键值对
        for (Map.Entry<String, Object> entry : queryConditions.entrySet()) {
            // 将每一个键值对添加到条件集合中
            conditionMap.put(entry.getKey(), entry.getValue());
        }

        return service.XqmZsbBKName(conditionMap);
    }
    /**
     * 接口五： 按专业：本科代码 查询对应 本科专业学校相关信息  《多选》
     */
    @PostMapping("/XqmZsbMajorSchoolIn")
    public List<Schoolmajorinfo> XqmZsbMajorSchoolIn(@RequestBody Map<String, Object> queryConditions) {
        // 创建一个存储查询条件的对象或Map
        Map<String, Object> conditionMap = new HashMap<>();

        // 针对"name"字段进行特殊处理，将其从字符串转换为列表
        if (queryConditions.containsKey("underMajorCode")) {
            String namesStr = (String) queryConditions.get("underMajorCode");
            conditionMap.put("underMajorCodes", namesStr.split(","));
        } else {
            // 如果没有提供"name"字段，则无需特殊处理，直接将其他键值对添加到条件集合中
            for (Map.Entry<String, Object> entry : queryConditions.entrySet()) {
                conditionMap.put(entry.getKey(), entry.getValue());
            }
        }

        // 调用Service层的findWithNameIn方法
        return service.XqmZsbMajorSchoolIn(conditionMap);
    }
    /**
     * 接口六： 按学校：本科小类代码 查询对应 本科专业学校代码和名称
     */
    @PostMapping("/XqmZsbSchool")
    public List<Schoolmajorinfo> XqmZsbSchool(@RequestBody Map<String, Object> queryConditions) {
        // 创建一个存储查询条件的对象或Map
        Map<String, Object> conditionMap = new HashMap<>();

        // 遍历请求体中的所有键值对
        for (Map.Entry<String, Object> entry : queryConditions.entrySet()) {
            // 将每一个键值对添加到条件集合中
            conditionMap.put(entry.getKey(), entry.getValue());
        }

        return service.XqmZsbSchool(conditionMap);
    }
    /**
     * 接口七： 按学校：本科专业学校 查询对应 学校信息   《多选》
     */
    @PostMapping("/XqmZsbSchoolIn")
    public List<Schoolmajorinfo> XqmZsbSchoolIn(@RequestBody Map<String, Object> param) {
        // 直接创建一个存储查询条件的对象或Map
        Map<String, Object> SchoolMap = new HashMap<>();
        Map<String, Object> natureMap = new HashMap<>();

        // 针对"name"字段进行特殊处理，将其从字符串转换为列表
        if ( param.containsKey("underMajorSubCode")&& param.containsKey("universityCode")) {
            String schoolStr = (String) param.get("underMajorSubCode");
            SchoolMap.put("underMajorSubCode", schoolStr.split(","));
            SchoolMap.put("enrollingCollegeLength", schoolStr.length());
            String natureStr = (String) param.get("universityCode");
            natureMap.put("universityCode", natureStr.split(","));
            natureMap.put("schoolNatureLength", natureStr.length());
        }

        // 调用Service层的findWithSchool方法
        return service.XqmZsbSchoolIn(SchoolMap,natureMap);
    }
}
